package autogen;

import sketch.ounit.Values;
import treemap.TreeMap;
import junit.framework.TestCase;

public class TreeMapRemoveExpand_Auto_Gen extends TestCase {
public void testRemove0(){
  Integer[] is_0=new Integer[]{};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove1(){
  Integer[] is_0=new Integer[]{2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove2(){
  Integer[] is_0=new Integer[]{3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove3(){
  Integer[] is_0=new Integer[]{4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove4(){
  Integer[] is_0=new Integer[]{1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove5(){
  Integer[] is_0=new Integer[]{2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove6(){
  Integer[] is_0=new Integer[]{3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove7(){
  Integer[] is_0=new Integer[]{4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove8(){
  Integer[] is_0=new Integer[]{1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove9(){
  Integer[] is_0=new Integer[]{2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove10(){
  Integer[] is_0=new Integer[]{3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove11(){
  Integer[] is_0=new Integer[]{4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove12(){
  Integer[] is_0=new Integer[]{1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove13(){
  Integer[] is_0=new Integer[]{2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove14(){
  Integer[] is_0=new Integer[]{3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove15(){
  Integer[] is_0=new Integer[]{4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove16(){
  Integer[] is_0=new Integer[]{1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove17(){
  Integer[] is_0=new Integer[]{2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove18(){
  Integer[] is_0=new Integer[]{3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove19(){
  Integer[] is_0=new Integer[]{4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove20(){
  Integer[] is_0=new Integer[]{1,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove21(){
  Integer[] is_0=new Integer[]{2,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove22(){
  Integer[] is_0=new Integer[]{3,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove23(){
  Integer[] is_0=new Integer[]{4,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove24(){
  Integer[] is_0=new Integer[]{1,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove25(){
  Integer[] is_0=new Integer[]{2,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove26(){
  Integer[] is_0=new Integer[]{3,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove27(){
  Integer[] is_0=new Integer[]{4,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove28(){
  Integer[] is_0=new Integer[]{1,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove29(){
  Integer[] is_0=new Integer[]{2,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove30(){
  Integer[] is_0=new Integer[]{3,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove31(){
  Integer[] is_0=new Integer[]{4,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove32(){
  Integer[] is_0=new Integer[]{1,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove33(){
  Integer[] is_0=new Integer[]{2,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove34(){
  Integer[] is_0=new Integer[]{3,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove35(){
  Integer[] is_0=new Integer[]{4,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove36(){
  Integer[] is_0=new Integer[]{1,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove37(){
  Integer[] is_0=new Integer[]{2,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove38(){
  Integer[] is_0=new Integer[]{3,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove39(){
  Integer[] is_0=new Integer[]{4,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove40(){
  Integer[] is_0=new Integer[]{1,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove41(){
  Integer[] is_0=new Integer[]{2,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove42(){
  Integer[] is_0=new Integer[]{3,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove43(){
  Integer[] is_0=new Integer[]{4,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove44(){
  Integer[] is_0=new Integer[]{1,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove45(){
  Integer[] is_0=new Integer[]{2,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove46(){
  Integer[] is_0=new Integer[]{3,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove47(){
  Integer[] is_0=new Integer[]{4,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove48(){
  Integer[] is_0=new Integer[]{1,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove49(){
  Integer[] is_0=new Integer[]{2,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove50(){
  Integer[] is_0=new Integer[]{3,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove51(){
  Integer[] is_0=new Integer[]{4,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove52(){
  Integer[] is_0=new Integer[]{1,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove53(){
  Integer[] is_0=new Integer[]{2,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove54(){
  Integer[] is_0=new Integer[]{3,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove55(){
  Integer[] is_0=new Integer[]{4,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove56(){
  Integer[] is_0=new Integer[]{1,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove57(){
  Integer[] is_0=new Integer[]{2,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove58(){
  Integer[] is_0=new Integer[]{3,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove59(){
  Integer[] is_0=new Integer[]{4,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove60(){
  Integer[] is_0=new Integer[]{1,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove61(){
  Integer[] is_0=new Integer[]{2,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove62(){
  Integer[] is_0=new Integer[]{3,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove63(){
  Integer[] is_0=new Integer[]{4,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove64(){
  Integer[] is_0=new Integer[]{1,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove65(){
  Integer[] is_0=new Integer[]{2,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove66(){
  Integer[] is_0=new Integer[]{3,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove67(){
  Integer[] is_0=new Integer[]{4,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove68(){
  Integer[] is_0=new Integer[]{1,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove69(){
  Integer[] is_0=new Integer[]{2,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove70(){
  Integer[] is_0=new Integer[]{3,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove71(){
  Integer[] is_0=new Integer[]{4,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove72(){
  Integer[] is_0=new Integer[]{1,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove73(){
  Integer[] is_0=new Integer[]{2,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove74(){
  Integer[] is_0=new Integer[]{3,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove75(){
  Integer[] is_0=new Integer[]{4,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove76(){
  Integer[] is_0=new Integer[]{1,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove77(){
  Integer[] is_0=new Integer[]{2,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove78(){
  Integer[] is_0=new Integer[]{3,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove79(){
  Integer[] is_0=new Integer[]{4,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove80(){
  Integer[] is_0=new Integer[]{1,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove81(){
  Integer[] is_0=new Integer[]{2,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove82(){
  Integer[] is_0=new Integer[]{3,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove83(){
  Integer[] is_0=new Integer[]{4,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove84(){
  Integer[] is_0=new Integer[]{1,1,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove85(){
  Integer[] is_0=new Integer[]{2,1,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove86(){
  Integer[] is_0=new Integer[]{3,1,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove87(){
  Integer[] is_0=new Integer[]{4,1,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove88(){
  Integer[] is_0=new Integer[]{1,2,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove89(){
  Integer[] is_0=new Integer[]{2,2,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove90(){
  Integer[] is_0=new Integer[]{3,2,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove91(){
  Integer[] is_0=new Integer[]{4,2,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove92(){
  Integer[] is_0=new Integer[]{1,3,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove93(){
  Integer[] is_0=new Integer[]{2,3,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove94(){
  Integer[] is_0=new Integer[]{3,3,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove95(){
  Integer[] is_0=new Integer[]{4,3,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove96(){
  Integer[] is_0=new Integer[]{1,4,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove97(){
  Integer[] is_0=new Integer[]{2,4,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove98(){
  Integer[] is_0=new Integer[]{3,4,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove99(){
  Integer[] is_0=new Integer[]{4,4,1,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove100(){
  Integer[] is_0=new Integer[]{1,1,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove101(){
  Integer[] is_0=new Integer[]{2,1,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove102(){
  Integer[] is_0=new Integer[]{3,1,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove103(){
  Integer[] is_0=new Integer[]{4,1,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove104(){
  Integer[] is_0=new Integer[]{1,2,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove105(){
  Integer[] is_0=new Integer[]{2,2,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove106(){
  Integer[] is_0=new Integer[]{3,2,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove107(){
  Integer[] is_0=new Integer[]{4,2,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove108(){
  Integer[] is_0=new Integer[]{1,3,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove109(){
  Integer[] is_0=new Integer[]{2,3,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove110(){
  Integer[] is_0=new Integer[]{3,3,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove111(){
  Integer[] is_0=new Integer[]{4,3,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove112(){
  Integer[] is_0=new Integer[]{1,4,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove113(){
  Integer[] is_0=new Integer[]{2,4,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove114(){
  Integer[] is_0=new Integer[]{3,4,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove115(){
  Integer[] is_0=new Integer[]{4,4,2,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove116(){
  Integer[] is_0=new Integer[]{1,1,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove117(){
  Integer[] is_0=new Integer[]{2,1,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove118(){
  Integer[] is_0=new Integer[]{3,1,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove119(){
  Integer[] is_0=new Integer[]{4,1,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove120(){
  Integer[] is_0=new Integer[]{1,2,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove121(){
  Integer[] is_0=new Integer[]{2,2,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove122(){
  Integer[] is_0=new Integer[]{3,2,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove123(){
  Integer[] is_0=new Integer[]{4,2,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove124(){
  Integer[] is_0=new Integer[]{1,3,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove125(){
  Integer[] is_0=new Integer[]{2,3,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove126(){
  Integer[] is_0=new Integer[]{3,3,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove127(){
  Integer[] is_0=new Integer[]{4,3,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove128(){
  Integer[] is_0=new Integer[]{1,4,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove129(){
  Integer[] is_0=new Integer[]{2,4,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove130(){
  Integer[] is_0=new Integer[]{3,4,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove131(){
  Integer[] is_0=new Integer[]{4,4,3,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove132(){
  Integer[] is_0=new Integer[]{1,1,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove133(){
  Integer[] is_0=new Integer[]{2,1,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove134(){
  Integer[] is_0=new Integer[]{3,1,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove135(){
  Integer[] is_0=new Integer[]{4,1,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove136(){
  Integer[] is_0=new Integer[]{1,2,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove137(){
  Integer[] is_0=new Integer[]{2,2,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove138(){
  Integer[] is_0=new Integer[]{3,2,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove139(){
  Integer[] is_0=new Integer[]{4,2,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove140(){
  Integer[] is_0=new Integer[]{1,3,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove141(){
  Integer[] is_0=new Integer[]{2,3,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove142(){
  Integer[] is_0=new Integer[]{3,3,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove143(){
  Integer[] is_0=new Integer[]{4,3,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove144(){
  Integer[] is_0=new Integer[]{1,4,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove145(){
  Integer[] is_0=new Integer[]{2,4,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove146(){
  Integer[] is_0=new Integer[]{3,4,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove147(){
  Integer[] is_0=new Integer[]{4,4,4,1};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove148(){
  Integer[] is_0=new Integer[]{1,1,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove149(){
  Integer[] is_0=new Integer[]{2,1,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove150(){
  Integer[] is_0=new Integer[]{3,1,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove151(){
  Integer[] is_0=new Integer[]{4,1,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove152(){
  Integer[] is_0=new Integer[]{1,2,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove153(){
  Integer[] is_0=new Integer[]{2,2,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove154(){
  Integer[] is_0=new Integer[]{3,2,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove155(){
  Integer[] is_0=new Integer[]{4,2,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove156(){
  Integer[] is_0=new Integer[]{1,3,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove157(){
  Integer[] is_0=new Integer[]{2,3,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove158(){
  Integer[] is_0=new Integer[]{3,3,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove159(){
  Integer[] is_0=new Integer[]{4,3,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove160(){
  Integer[] is_0=new Integer[]{1,4,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove161(){
  Integer[] is_0=new Integer[]{2,4,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove162(){
  Integer[] is_0=new Integer[]{3,4,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove163(){
  Integer[] is_0=new Integer[]{4,4,1,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove164(){
  Integer[] is_0=new Integer[]{1,1,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove165(){
  Integer[] is_0=new Integer[]{2,1,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove166(){
  Integer[] is_0=new Integer[]{3,1,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove167(){
  Integer[] is_0=new Integer[]{4,1,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove168(){
  Integer[] is_0=new Integer[]{1,2,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove169(){
  Integer[] is_0=new Integer[]{2,2,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove170(){
  Integer[] is_0=new Integer[]{3,2,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove171(){
  Integer[] is_0=new Integer[]{4,2,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove172(){
  Integer[] is_0=new Integer[]{1,3,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove173(){
  Integer[] is_0=new Integer[]{2,3,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove174(){
  Integer[] is_0=new Integer[]{3,3,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove175(){
  Integer[] is_0=new Integer[]{4,3,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove176(){
  Integer[] is_0=new Integer[]{1,4,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove177(){
  Integer[] is_0=new Integer[]{2,4,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove178(){
  Integer[] is_0=new Integer[]{3,4,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove179(){
  Integer[] is_0=new Integer[]{4,4,2,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove180(){
  Integer[] is_0=new Integer[]{1,1,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove181(){
  Integer[] is_0=new Integer[]{2,1,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove182(){
  Integer[] is_0=new Integer[]{3,1,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove183(){
  Integer[] is_0=new Integer[]{4,1,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove184(){
  Integer[] is_0=new Integer[]{1,2,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove185(){
  Integer[] is_0=new Integer[]{2,2,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove186(){
  Integer[] is_0=new Integer[]{3,2,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove187(){
  Integer[] is_0=new Integer[]{4,2,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove188(){
  Integer[] is_0=new Integer[]{1,3,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove189(){
  Integer[] is_0=new Integer[]{2,3,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove190(){
  Integer[] is_0=new Integer[]{3,3,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove191(){
  Integer[] is_0=new Integer[]{4,3,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove192(){
  Integer[] is_0=new Integer[]{1,4,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove193(){
  Integer[] is_0=new Integer[]{2,4,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove194(){
  Integer[] is_0=new Integer[]{3,4,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove195(){
  Integer[] is_0=new Integer[]{4,4,3,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove196(){
  Integer[] is_0=new Integer[]{1,1,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove197(){
  Integer[] is_0=new Integer[]{2,1,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove198(){
  Integer[] is_0=new Integer[]{3,1,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove199(){
  Integer[] is_0=new Integer[]{4,1,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove200(){
  Integer[] is_0=new Integer[]{1,2,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove201(){
  Integer[] is_0=new Integer[]{2,2,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove202(){
  Integer[] is_0=new Integer[]{3,2,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove203(){
  Integer[] is_0=new Integer[]{4,2,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove204(){
  Integer[] is_0=new Integer[]{1,3,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove205(){
  Integer[] is_0=new Integer[]{2,3,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove206(){
  Integer[] is_0=new Integer[]{3,3,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove207(){
  Integer[] is_0=new Integer[]{4,3,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove208(){
  Integer[] is_0=new Integer[]{1,4,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove209(){
  Integer[] is_0=new Integer[]{2,4,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove210(){
  Integer[] is_0=new Integer[]{3,4,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove211(){
  Integer[] is_0=new Integer[]{4,4,4,2};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove212(){
  Integer[] is_0=new Integer[]{1,1,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove213(){
  Integer[] is_0=new Integer[]{2,1,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove214(){
  Integer[] is_0=new Integer[]{3,1,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove215(){
  Integer[] is_0=new Integer[]{4,1,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove216(){
  Integer[] is_0=new Integer[]{1,2,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove217(){
  Integer[] is_0=new Integer[]{2,2,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove218(){
  Integer[] is_0=new Integer[]{3,2,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove219(){
  Integer[] is_0=new Integer[]{4,2,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove220(){
  Integer[] is_0=new Integer[]{1,3,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove221(){
  Integer[] is_0=new Integer[]{2,3,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove222(){
  Integer[] is_0=new Integer[]{3,3,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove223(){
  Integer[] is_0=new Integer[]{4,3,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove224(){
  Integer[] is_0=new Integer[]{1,4,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove225(){
  Integer[] is_0=new Integer[]{2,4,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove226(){
  Integer[] is_0=new Integer[]{3,4,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove227(){
  Integer[] is_0=new Integer[]{4,4,1,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove228(){
  Integer[] is_0=new Integer[]{1,1,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove229(){
  Integer[] is_0=new Integer[]{2,1,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove230(){
  Integer[] is_0=new Integer[]{3,1,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove231(){
  Integer[] is_0=new Integer[]{4,1,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove232(){
  Integer[] is_0=new Integer[]{1,2,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove233(){
  Integer[] is_0=new Integer[]{2,2,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove234(){
  Integer[] is_0=new Integer[]{3,2,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove235(){
  Integer[] is_0=new Integer[]{4,2,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove236(){
  Integer[] is_0=new Integer[]{1,3,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove237(){
  Integer[] is_0=new Integer[]{2,3,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove238(){
  Integer[] is_0=new Integer[]{3,3,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove239(){
  Integer[] is_0=new Integer[]{4,3,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove240(){
  Integer[] is_0=new Integer[]{1,4,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove241(){
  Integer[] is_0=new Integer[]{2,4,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove242(){
  Integer[] is_0=new Integer[]{3,4,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove243(){
  Integer[] is_0=new Integer[]{4,4,2,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove244(){
  Integer[] is_0=new Integer[]{1,1,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove245(){
  Integer[] is_0=new Integer[]{2,1,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove246(){
  Integer[] is_0=new Integer[]{3,1,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove247(){
  Integer[] is_0=new Integer[]{4,1,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove248(){
  Integer[] is_0=new Integer[]{1,2,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove249(){
  Integer[] is_0=new Integer[]{2,2,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove250(){
  Integer[] is_0=new Integer[]{3,2,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove251(){
  Integer[] is_0=new Integer[]{4,2,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove252(){
  Integer[] is_0=new Integer[]{1,3,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove253(){
  Integer[] is_0=new Integer[]{2,3,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove254(){
  Integer[] is_0=new Integer[]{3,3,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove255(){
  Integer[] is_0=new Integer[]{4,3,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove256(){
  Integer[] is_0=new Integer[]{1,4,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove257(){
  Integer[] is_0=new Integer[]{2,4,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove258(){
  Integer[] is_0=new Integer[]{3,4,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove259(){
  Integer[] is_0=new Integer[]{4,4,3,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove260(){
  Integer[] is_0=new Integer[]{1,1,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove261(){
  Integer[] is_0=new Integer[]{2,1,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove262(){
  Integer[] is_0=new Integer[]{3,1,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove263(){
  Integer[] is_0=new Integer[]{4,1,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove264(){
  Integer[] is_0=new Integer[]{1,2,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove265(){
  Integer[] is_0=new Integer[]{2,2,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove266(){
  Integer[] is_0=new Integer[]{3,2,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove267(){
  Integer[] is_0=new Integer[]{4,2,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove268(){
  Integer[] is_0=new Integer[]{1,3,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove269(){
  Integer[] is_0=new Integer[]{2,3,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove270(){
  Integer[] is_0=new Integer[]{3,3,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove271(){
  Integer[] is_0=new Integer[]{4,3,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove272(){
  Integer[] is_0=new Integer[]{1,4,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove273(){
  Integer[] is_0=new Integer[]{2,4,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove274(){
  Integer[] is_0=new Integer[]{3,4,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove275(){
  Integer[] is_0=new Integer[]{4,4,4,3};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove276(){
  Integer[] is_0=new Integer[]{1,1,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove277(){
  Integer[] is_0=new Integer[]{2,1,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove278(){
  Integer[] is_0=new Integer[]{3,1,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove279(){
  Integer[] is_0=new Integer[]{4,1,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove280(){
  Integer[] is_0=new Integer[]{1,2,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove281(){
  Integer[] is_0=new Integer[]{2,2,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove282(){
  Integer[] is_0=new Integer[]{3,2,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove283(){
  Integer[] is_0=new Integer[]{4,2,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove284(){
  Integer[] is_0=new Integer[]{1,3,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove285(){
  Integer[] is_0=new Integer[]{2,3,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove286(){
  Integer[] is_0=new Integer[]{3,3,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove287(){
  Integer[] is_0=new Integer[]{4,3,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove288(){
  Integer[] is_0=new Integer[]{1,4,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove289(){
  Integer[] is_0=new Integer[]{2,4,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove290(){
  Integer[] is_0=new Integer[]{3,4,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove291(){
  Integer[] is_0=new Integer[]{4,4,1,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove292(){
  Integer[] is_0=new Integer[]{1,1,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove293(){
  Integer[] is_0=new Integer[]{2,1,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove294(){
  Integer[] is_0=new Integer[]{3,1,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove295(){
  Integer[] is_0=new Integer[]{4,1,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove296(){
  Integer[] is_0=new Integer[]{1,2,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove297(){
  Integer[] is_0=new Integer[]{2,2,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove298(){
  Integer[] is_0=new Integer[]{3,2,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove299(){
  Integer[] is_0=new Integer[]{4,2,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove300(){
  Integer[] is_0=new Integer[]{1,3,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove301(){
  Integer[] is_0=new Integer[]{2,3,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove302(){
  Integer[] is_0=new Integer[]{3,3,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove303(){
  Integer[] is_0=new Integer[]{4,3,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove304(){
  Integer[] is_0=new Integer[]{1,4,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove305(){
  Integer[] is_0=new Integer[]{2,4,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove306(){
  Integer[] is_0=new Integer[]{3,4,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove307(){
  Integer[] is_0=new Integer[]{4,4,2,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove308(){
  Integer[] is_0=new Integer[]{1,1,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove309(){
  Integer[] is_0=new Integer[]{2,1,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove310(){
  Integer[] is_0=new Integer[]{3,1,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove311(){
  Integer[] is_0=new Integer[]{4,1,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove312(){
  Integer[] is_0=new Integer[]{1,2,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove313(){
  Integer[] is_0=new Integer[]{2,2,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove314(){
  Integer[] is_0=new Integer[]{3,2,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove315(){
  Integer[] is_0=new Integer[]{4,2,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove316(){
  Integer[] is_0=new Integer[]{1,3,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove317(){
  Integer[] is_0=new Integer[]{2,3,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove318(){
  Integer[] is_0=new Integer[]{3,3,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove319(){
  Integer[] is_0=new Integer[]{4,3,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove320(){
  Integer[] is_0=new Integer[]{1,4,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove321(){
  Integer[] is_0=new Integer[]{2,4,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove322(){
  Integer[] is_0=new Integer[]{3,4,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove323(){
  Integer[] is_0=new Integer[]{4,4,3,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove324(){
  Integer[] is_0=new Integer[]{1,1,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove325(){
  Integer[] is_0=new Integer[]{2,1,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove326(){
  Integer[] is_0=new Integer[]{3,1,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove327(){
  Integer[] is_0=new Integer[]{4,1,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove328(){
  Integer[] is_0=new Integer[]{1,2,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove329(){
  Integer[] is_0=new Integer[]{2,2,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove330(){
  Integer[] is_0=new Integer[]{3,2,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove331(){
  Integer[] is_0=new Integer[]{4,2,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove332(){
  Integer[] is_0=new Integer[]{1,3,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove333(){
  Integer[] is_0=new Integer[]{2,3,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove334(){
  Integer[] is_0=new Integer[]{3,3,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove335(){
  Integer[] is_0=new Integer[]{4,3,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove336(){
  Integer[] is_0=new Integer[]{1,4,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove337(){
  Integer[] is_0=new Integer[]{2,4,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove338(){
  Integer[] is_0=new Integer[]{3,4,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

public void testRemove339(){
  Integer[] is_0=new Integer[]{4,4,4,4};
  TreeMap map=new TreeMap();
  for (  int i : is_0) {
    map.put(i);
  }
  map.remove(Values.symbolicInt());
}

}